export function typedPath<
    RootObjectType,
    HandlersType extends TypedPathHandlersConfig = Record<never, never>,
    OriginalObjectType =  RootObjectType,
>(
    additionalHandlers?: HandlersType,
    path: TypedPathKey[] = []
): TypedPathWrapper<RootObjectType, HandlersType & DefaultHandlers<RootObjectType>, OriginalObjectType> {}

type CustomTypedPathWrapper<T> = TypedPathWrapper<T, unknown, DefaultHandlers<T>>

export class Differences<T> {
  constructor(private changed: T, public raw: Array<Difference>) {}

  filter(pathFilter: CustomTypedPathWrapper<T>) {
    return this.raw.filter(({ path, value }) => matchPath(path, typedPathToRegex(pathFilter)))
  }
}

import diff, { Difference, DifferenceChange } from 'microdiff'
import { typedPath as originalTypedPath } from 'typed-path'

import { Quote } from '@/entities/Quote'

function getAdditionalHandlers<RootType>() {
  return {
    $rootType: () => ({} as RootType),
  }
}

const typedPath = <T>() => originalTypedPath<T, ReturnType<typeof getAdditionalHandlers<T>>>(getAdditionalHandlers<T>())

type TypedPathWrapper<T> = ReturnType<typeof typedPath<T>>

const matchPath = (path: (string | number)[], property: RegExp) => {
  const joined = path.join(`.`)
  return property.test(joined)
}

const typedPathToRegex = <T>(tp: TypedPathWrapper<T>) => {
  const regex = new RegExp(tp.$rawPath.join(`.`).replace(/\d+/g, `\\d+`))
  return regex
}

export type { Difference }

type DifferenceTypes = Difference[`type`]

export class Differences<T> {
  constructor(private changed: T, public raw: Array<Difference>) {}

  filter({
    pathFilter,
    typeFilter,
    valueFilter,
  }: {
    pathFilter?: TypedPathWrapper<T>
    typeFilter?: (type: DifferenceTypes) => boolean
    valueFilter?: (value: any, oldValue?: any) => boolean
  }) {
    return this.raw.filter((d) => {
      let pathMatch = true
      let typeMatch = true
      let valueMatch = true

      if (pathFilter) {
        pathMatch = matchPath(d.path, typedPathToRegex(pathFilter))
      }

      if (typeFilter) {
        typeMatch = typeFilter(d.type)
      }

      if (valueFilter) {
        const { value, oldValue } = d as DifferenceChange
        valueMatch = valueFilter(value, oldValue)
      }

      return pathMatch && typeMatch && valueMatch
    })
  }
}

export const getDifferences = <T extends Record<string, any> | any[]>(left: T, right: T) =>
  new Differences<T>(left, diff(left, right))

const differences = new Differences(Quote, [])
differences.filter(typedPath<Quote>().loads[0].status)